home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 4 / Meeting Pearls Vol. IV (1996)(GTI - Schatztruhe)[!].iso / Pearls / gfx / Viewer / CyberAnim / source.lha / unpack.s < prev   
Text File  |  1996-09-08  |  11KB  |  452 lines
  1.         multipass
  2.         mc68000
  3.  
  4.         xdef    _unpackbytedelta
  5.         xdef    _unpackbytedeltanodirty
  6.         xdef    _unpackanim7long
  7.         xdef    _unpackanim7longnodirty
  8.  
  9. ;void __asm unpackbytedelta (register __a0 BYTE *bdata,
  10. ;                            register __a1 PLANEPTR plane,
  11. ;                            register __d0 WORD bytesperrow,
  12. ;                            register __a2 WORD *dirty);
  13.  
  14. ; d1 = x
  15. ; d2 = tmp
  16. ; d3 = count
  17. ; d4 = w
  18. ; d5 = first
  19. ; d6 = last
  20. ; d7 = ub, temporary
  21.  
  22. ; a3 = bp
  23. ; a4 = y
  24.  
  25. _unpackbytedelta
  26.         movem.l    d2-d7/a2-a4,-(sp)
  27.         ext.l    d0        ; bytesperrow
  28.         moveq    #0,d1        ; x = 0
  29. .xloop        moveq    #-1,d5        ; first = -1
  30.         moveq    #-1,d6        ; last = -1
  31.         movea.l    a1,a3        ; bp = plane
  32.         addq.l    #1,a1        ; plane++
  33.         suba.l    a4,a4        ; y = 0
  34.         moveq    #0,d3
  35.         move.b    (a0)+,d3    ; count = *bdata++
  36.         bra    .endloop2
  37. .loop2        moveq    #0,d4
  38.         move.b    (a0)+,d4    ; w = *bdata++
  39.         ble    1$        ; branch if w <= 0
  40.         adda.l    d4,a4        ; y += w
  41.         mulu.w    d0,d4
  42.         adda.l    d4,a3        ; bp += w * bytesperrow
  43. .endloop2    dbra    d3,.loop2
  44.         bra    .endxloop
  45.  
  46. 1$        beq    3$        ; branch if w == 0
  47.         tst.w    d5
  48.         bge    2$        ; branch if first >= 0
  49.         move.w    a4,d5        ; first = y
  50. 2$        and.w    #$7f,d4        ; w &= 0x7f
  51.         adda.l    d4,a4        ; y += w
  52.         move.w    a4,d6        ; last = y
  53.         move.w    d4,d7
  54.         lsr.w    #3,d4
  55.         and.w    #7,d7
  56.         add.w    d7,d7
  57.         add.w    d7,d7
  58.         neg.w    d7
  59.         jmp    (.endwloop,pc,d7.w)
  60. .wloop        move.b    (a0)+,(a3)    ; *bp = *data++
  61.         adda.l    d0,a3        ; bp += bytesperrow
  62.         move.b    (a0)+,(a3)    ; *bp = *data++
  63.         adda.l    d0,a3        ; bp += bytesperrow
  64.         move.b    (a0)+,(a3)    ; *bp = *data++
  65.         adda.l    d0,a3        ; bp += bytesperrow
  66.         move.b    (a0)+,(a3)    ; *bp = *data++
  67.         adda.l    d0,a3        ; bp += bytesperrow
  68.         move.b    (a0)+,(a3)    ; *bp = *data++
  69.         adda.l    d0,a3        ; bp += bytesperrow
  70.         move.b    (a0)+,(a3)    ; *bp = *data++
  71.         adda.l    d0,a3        ; bp += bytesperrow
  72.         move.b    (a0)+,(a3)    ; *bp = *data++
  73.         adda.l    d0,a3        ; bp += bytesperrow
  74.         move.b    (a0)+,(a3)    ; *bp = *data++
  75.         adda.l    d0,a3        ; bp += bytesperrow
  76. .endwloop    dbra    d4,.wloop
  77.         dbra    d3,.loop2
  78.         bra    .endxloop
  79.  
  80. 3$        tst.w    d5
  81.         bge    4$        ; branch if first >= 0
  82.         move.w    a4,d5        ; first = y
  83. 4$        moveq    #0,d7
  84.         move.b    (a0)+,d7    ; ub = *bdata++
  85.         adda.l    d7,a4        ; y += ub
  86.         move.w    a4,d6        ; last = y
  87.         move.b    (a0)+,d4    ; w = *bdata++
  88.         move.w    d7,d2
  89.         lsr.w    #3,d7
  90.         and.w    #7,d2
  91.         add.w    d2,d2
  92.         add.w    d2,d2
  93.         neg.w    d2
  94.         jmp    (.endubloop,pc,d2.w)
  95. .ubloop        move.b    d4,(a3)        ; *bp = w
  96.         adda.l    d0,a3        ; bp += bytesperrow
  97.         move.b    d4,(a3)        ; *bp = w
  98.         adda.l    d0,a3        ; bp += bytesperrow
  99.         move.b    d4,(a3)        ; *bp = w
  100.         adda.l    d0,a3        ; bp += bytesperrow
  101.         move.b    d4,(a3)        ; *bp = w
  102.         adda.l    d0,a3        ; bp += bytesperrow
  103.         move.b    d4,(a3)        ; *bp = w
  104.         adda.l    d0,a3        ; bp += bytesperrow
  105.         move.b    d4,(a3)        ; *bp = w
  106.         adda.l    d0,a3        ; bp += bytesperrow
  107.         move.b    d4,(a3)        ; *bp = w
  108.         adda.l    d0,a3        ; bp += bytesperrow
  109.         move.b    d4,(a3)        ; *bp = w
  110.         adda.l    d0,a3        ; bp += bytesperrow
  111. .endubloop    dbra    d7,.ubloop
  112.  
  113.         dbra    d3,.loop2
  114.  
  115. .endxloop    tst.w    d5
  116.         blt    8$        ; branch if first < 0
  117.         move.w    (a2),d7
  118.         blt    5$        ; branch if dirty[0] < 0
  119.         cmp.w    d5,d7
  120.         ble    6$        ; branch if dirty[0] <= first
  121. 5$        move.w    d5,(a2)        ; dirty[0] = first
  122. 6$        move.w    (2,a2),d7
  123.         blt    7$        ; branch if dirty[1] < 0
  124.         cmp.w    d6,d7
  125.         bge    8$        ; branch if dirty[1] >= last
  126. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  127. 8$        move.w    d1,d7
  128.         and.w    #3,d7
  129.         cmp.w    #3,d7
  130.         bne    9$
  131.         addq.l    #4,a2        ; dirty += 2
  132. 9$        addq.w    #1,d1        ; x++
  133.         cmp.w    d0,d1
  134.         blt    .xloop        ; branch if x < bytesperrow
  135.         movem.l    (sp)+,d2-d7/a2-a4
  136.         rts
  137.  
  138. ;{
  139. ;  WORD x, y, count, w, first, last;
  140. ;  BYTE *bp;
  141. ;  UBYTE ub;
  142. ;
  143. ;  for (x = 0; x < bytesperrow; x++) {
  144. ;    first = -1;
  145. ;    last = -1;
  146. ;    bp = &plane[x];
  147. ;    y = 0;
  148. ;    for (count = *bdata++; count > 0; count--) {
  149. ;      if ((w = *bdata++) > 0) {
  150. ;        y += w;
  151. ;        bp += w * bytesperrow;
  152. ;      } else if (w < 0) {
  153. ;        if (first < 0)
  154. ;          first = y;
  155. ;        last = (y += (w &= 0x7f));
  156. ;        for ( ; w > 0; w--) {
  157. ;          *bp = *bdata++;
  158. ;          bp += bytesperrow;
  159. ;        }
  160. ;      } else /* w == 0 */ {
  161. ;        if (first < 0)
  162. ;          first = y;
  163. ;        last = (y += (ub = (UBYTE)*bdata++));
  164. ;        w = *bdata++;
  165. ;        for ( ; ub > 0; ub--) {
  166. ;          *bp = w;
  167. ;          bp += bytesperrow;
  168. ;        }
  169. ;      }
  170. ;    }
  171. ;    if (first >= 0 && (dirty[0] < 0 || first < dirty[0]))
  172. ;      dirty[0] = first;
  173. ;    if (last >= 0 && (dirty[1] < 0 || last > dirty[1]))
  174. ;      dirty[1] = last;
  175. ;    if ((x & 3) == 3)
  176. ;      dirty += 2;
  177. ;  }
  178. ;}
  179.  
  180. ;void __asm unpackbytedeltanodirty (register __a0 BYTE *bdata,
  181. ;                                   register __a1 PLANEPTR plane,
  182. ;                                   register __d0 WORD bytesperrow);
  183.  
  184. ; d1 = bytesperrrow - x
  185. ; d3 = count
  186. ; d4 = w
  187. ; d7 = ub, temporary
  188.  
  189. ; a3 = bp
  190.  
  191. _unpackbytedeltanodirty
  192.         movem.l    d2-d7/a2-a3,-(sp)
  193.         ext.l    d0        ; bytesperrow
  194.         move.l    d0,d1        ; x
  195.         bra    .endxloop
  196. .xloop        movea.l    a1,a3        ; bp = plane
  197.         addq.l    #1,a1        ; plane++
  198.         moveq    #0,d3
  199.         move.b    (a0)+,d3    ; count = *bdata++
  200.         bra    .endloop2
  201.  
  202. .loop2        moveq    #0,d4
  203.         move.b    (a0)+,d4    ; w = *bdata++
  204.         ble    1$        ; branch if w <= 0
  205.         mulu.w    d0,d4
  206.         adda.l    d4,a3        ; bp += w * bytesperrow
  207.  
  208. .endloop2    dbra    d3,.loop2
  209.         bra    .endxloop
  210.  
  211. 1$        beq    3$        ; branch if w == 0
  212.         and.w    #$7f,d4        ; w &= 0x7f
  213.         move.w    d4,d6
  214.         lsr.w    #3,d4
  215.         and.w    #7,d6
  216.         add.w    d6,d6
  217.         add.w    d6,d6
  218.         neg.w    d6
  219.         jmp    (.endwloop,pc,d6.w)
  220. .wloop        move.b    (a0)+,(a3)    ; *lp = *data++
  221.         adda.l    d0,a3        ; lp += bytesperrow
  222.         move.b    (a0)+,(a3)    ; *lp = *data++
  223.         adda.l    d0,a3        ; lp += bytesperrow
  224.         move.b    (a0)+,(a3)    ; *lp = *data++
  225.         adda.l    d0,a3        ; lp += bytesperrow
  226.         move.b    (a0)+,(a3)    ; *lp = *data++
  227.         adda.l    d0,a3        ; lp += bytesperrow
  228.         move.b    (a0)+,(a3)    ; *lp = *data++
  229.         adda.l    d0,a3        ; lp += bytesperrow
  230.         move.b    (a0)+,(a3)    ; *lp = *data++
  231.         adda.l    d0,a3        ; lp += bytesperrow
  232.         move.b    (a0)+,(a3)    ; *lp = *data++
  233.         adda.l    d0,a3        ; lp += bytesperrow
  234.         move.b    (a0)+,(a3)    ; *lp = *data++
  235.         adda.l    d0,a3        ; lp += bytesperrow
  236. .endwloop    dbra    d4,.wloop
  237.  
  238.         dbra    d3,.loop2
  239.         bra    .endxloop
  240.  
  241. 3$        moveq    #0,d7
  242.         move.b    (a0)+,d7    ; ub = *bdata++
  243.         move.b    (a0)+,d4    ; w = *bdata++
  244.         move.w    d7,d6
  245.         lsr.w    #3,d7
  246.         and.w    #7,d6
  247.         add.w    d6,d6
  248.         add.w    d6,d6
  249.         neg.w    d6
  250.         jmp    (.endubloop,pc,d6.w)
  251. .ubloop        move.b    d4,(a3)        ; *lp = w
  252.         adda.l    d0,a3        ; lp += bytesperrow
  253.         move.b    d4,(a3)        ; *lp = w
  254.         adda.l    d0,a3        ; lp += bytesperrow
  255.         move.b    d4,(a3)        ; *lp = w
  256.         adda.l    d0,a3        ; lp += bytesperrow
  257.         move.b    d4,(a3)        ; *lp = w
  258.         adda.l    d0,a3        ; lp += bytesperrow
  259.         move.b    d4,(a3)        ; *lp = w
  260.         adda.l    d0,a3        ; lp += bytesperrow
  261.         move.b    d4,(a3)        ; *lp = w
  262.         adda.l    d0,a3        ; lp += bytesperrow
  263.         move.b    d4,(a3)        ; *lp = w
  264.         adda.l    d0,a3        ; lp += bytesperrow
  265.         move.b    d4,(a3)        ; *lp = w
  266.         adda.l    d0,a3        ; lp += bytesperrow
  267. .endubloop    dbra    d7,.ubloop
  268.  
  269.         dbra    d3,.loop2
  270.  
  271. .endxloop    dbra    d1,.xloop
  272.         movem.l    (sp)+,d2-d7/a2-a3
  273.         rts
  274.  
  275.  
  276. ;void __asm unpackanim7long (register __a0 BYTE *bdata,
  277. ;                            register __a4 LONG *data,
  278. ;                            register __a1 PLANEPTR plane,
  279. ;                            register __d0 WORD bytesperrow,
  280. ;                            register __a2 WORD *dirty);
  281.  
  282. ; d1 = x
  283. ; d2 = y
  284. ; d3 = count
  285. ; d4 = w
  286. ; d5 = first
  287. ; d6 = last
  288. ; d7 = ub, temporary
  289.  
  290. ; a3 = lp
  291.  
  292. _unpackanim7long
  293.         movem.l    d2-d7/a2-a4,-(sp)
  294.         ext.l    d0        ; bytesperrow
  295.         moveq    #0,d1        ; x = 0
  296. .xloop        moveq    #-1,d5        ; first = -1
  297.         moveq    #-1,d6        ; last = -1
  298.         movea.l    a1,a3        ; lp = plane
  299.         addq.l    #4,a1        ; plane++
  300.         moveq    #0,d2        ; y = 0
  301.         moveq    #0,d3
  302.         move.b    (a0)+,d3    ; count = *bdata++
  303.         bra    .endloop2
  304. .loop2        moveq    #0,d4
  305.         move.b    (a0)+,d4    ; w = *bdata++
  306.         ble    1$        ; branch if w <= 0
  307.         add.w    d4,d2        ; y += w
  308.         mulu.w    d0,d4
  309.         adda.l    d4,a3        ; lp += w * bytesperrow
  310.         bra    .endloop2
  311. 1$        beq    3$        ; branch if w == 0
  312.         tst.w    d5
  313.         bge    2$        ; branch if first >= 0
  314.         move.w    d2,d5        ; first = y
  315. 2$        and.w    #$7f,d4        ; w &= 0x7f
  316.         add.w    d4,d2        ; y += w
  317.         move.w    d2,d6        ; last = y
  318.         bra    .endwloop
  319. .wloop        move.l    (a4)+,(a3)    ; *lp = *data++
  320.         adda.l    d0,a3        ; lp += bytesperrow
  321. .endwloop    dbra    d4,.wloop
  322.         bra    .endloop2
  323. 3$        tst.w    d5
  324.         bge    4$        ; branch if first >= 0
  325.         move.w    d2,d5        ; first = y
  326. 4$        moveq    #0,d7
  327.         move.b    (a0)+,d7    ; ub = *bdata++
  328.         add.w    d7,d2        ; y += ub
  329.         move.w    d2,d6        ; last = y
  330.         move.l    (a4)+,d4    ; w = *data++
  331.         bra    .endubloop
  332. .ubloop        move.l    d4,(a3)        ; *lp = w
  333.         adda.l    d0,a3        ; lp += bytesperrow
  334. .endubloop    dbra    d7,.ubloop
  335. .endloop2    dbra    d3,.loop2
  336.         tst.w    d5
  337.         blt    8$        ; branch if first < 0
  338.         move.w    (a2),d7
  339.         blt    5$        ; branch if dirty[0] < 0
  340.         cmp.w    d5,d7
  341.         ble    6$        ; branch if dirty[0] <= first
  342. 5$        move.w    d5,(a2)        ; dirty[0] = first
  343. 6$        move.w    (2,a2),d7
  344.         blt    7$        ; branch if dirty[1] < 0
  345.         cmp.w    d6,d7
  346.         bge    8$        ; branch if dirty[1] >= last
  347. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  348. 8$        addq.l    #4,a2        ; dirty += 2
  349.         addq.w    #4,d1        ; x += 4
  350.         cmp.w    d0,d1
  351.         blt    .xloop        ; branch if x < bytesperrow
  352.         movem.l    (sp)+,d2-d7/a2-a4
  353.         rts
  354.  
  355. ;void __asm unpackanim7longnodirty (register __a0 BYTE *bdata,
  356. ;                                   register __a4 LONG *data,
  357. ;                                   register __a1 PLANEPTR plane,
  358. ;                                   register __d0 WORD bytesperrow);
  359.  
  360. ; d1 = (bytesperrow - x) >> 2
  361. ; d3 = count
  362. ; d4 = w
  363. ; d7 = ub, temporary
  364.  
  365. ; a3 = lp
  366.  
  367. _unpackanim7longnodirty
  368.         movem.l    d2-d7/a2-a4,-(sp)
  369.         ext.l    d0        ; bytesperrow
  370.         move.w    d0,d1
  371.         lsr.w    #2,d1
  372.         bra    .endxloop
  373. .xloop        movea.l    a1,a3        ; lp = plane
  374.         addq.l    #4,a1        ; plane++
  375.         moveq    #0,d3
  376.         move.b    (a0)+,d3    ; count = *bdata++
  377.         bra    .endloop2
  378.  
  379. .loop2        moveq    #0,d4
  380.         move.b    (a0)+,d4    ; w = *bdata++
  381.         ble    1$        ; branch if w <= 0
  382.         mulu.w    d0,d4
  383.         adda.l    d4,a3        ; lp += w * bytesperrow
  384.  
  385. .endloop2    dbra    d3,.loop2
  386.         bra    .endxloop
  387.  
  388. 1$        beq    3$        ; branch if w == 0
  389. 2$        and.w    #$7f,d4        ; w &= 0x7f
  390.         move.w    d4,d6
  391.         lsr.w    #3,d4
  392.         and.w    #7,d6
  393.         add.w    d6,d6
  394.         add.w    d6,d6
  395.         neg.w    d6
  396.         jmp    (.endwloop,pc,d6.w)
  397. .wloop        move.l    (a4)+,(a3)    ; *lp = *data++
  398.         adda.l    d0,a3        ; lp += bytesperrow
  399.         move.l    (a4)+,(a3)    ; *lp = *data++
  400.         adda.l    d0,a3        ; lp += bytesperrow
  401.         move.l    (a4)+,(a3)    ; *lp = *data++
  402.         adda.l    d0,a3        ; lp += bytesperrow
  403.         move.l    (a4)+,(a3)    ; *lp = *data++
  404.         adda.l    d0,a3        ; lp += bytesperrow
  405.         move.l    (a4)+,(a3)    ; *lp = *data++
  406.         adda.l    d0,a3        ; lp += bytesperrow
  407.         move.l    (a4)+,(a3)    ; *lp = *data++
  408.         adda.l    d0,a3        ; lp += bytesperrow
  409.         move.l    (a4)+,(a3)    ; *lp = *data++
  410.         adda.l    d0,a3        ; lp += bytesperrow
  411.         move.l    (a4)+,(a3)    ; *lp = *data++
  412.         adda.l    d0,a3        ; lp += bytesperrow
  413. .endwloop    dbra    d4,.wloop
  414.  
  415.         dbra    d3,.loop2
  416.         bra    .endxloop
  417.  
  418. 3$        moveq    #0,d7
  419.         move.b    (a0)+,d7    ; ub = *bdata++
  420.         move.l    (a4)+,d4    ; w = *data++
  421.         move.w    d7,d6
  422.         lsr.w    #3,d7
  423.         and.w    #7,d6
  424.         add.w    d6,d6
  425.         add.w    d6,d6
  426.         neg.w    d6
  427.         jmp    (.endubloop,pc,d6.w)
  428. .ubloop        move.l    d4,(a3)        ; *lp = w
  429.         adda.l    d0,a3        ; lp += bytesperrow
  430.         move.l    d4,(a3)        ; *lp = w
  431.         adda.l    d0,a3        ; lp += bytesperrow
  432.         move.l    d4,(a3)        ; *lp = w
  433.         adda.l    d0,a3        ; lp += bytesperrow
  434.         move.l    d4,(a3)        ; *lp = w
  435.         adda.l    d0,a3        ; lp += bytesperrow
  436.         move.l    d4,(a3)        ; *lp = w
  437.         adda.l    d0,a3        ; lp += bytesperrow
  438.         move.l    d4,(a3)        ; *lp = w
  439.         adda.l    d0,a3        ; lp += bytesperrow
  440.         move.l    d4,(a3)        ; *lp = w
  441.         adda.l    d0,a3        ; lp += bytesperrow
  442.         move.l    d4,(a3)        ; *lp = w
  443.         adda.l    d0,a3        ; lp += bytesperrow
  444. .endubloop    dbra    d7,.ubloop
  445.  
  446.         dbra    d3,.loop2
  447. .endxloop    dbra    d1,.xloop
  448.         movem.l    (sp)+,d2-d7/a2-a4
  449.         rts
  450.  
  451.         end
  452.